/**
 * 获取上个月份
 * 输出：'2023-05'
 */
export function lastMonth() {
    var year = new Date().getFullYear()
    var month = new Date().getMonth()
    var newDate = ''

    if (month == 0) {
        newDate = year - 1 + '-12'
    } else if (month >= 10) {
        newDate = year + '-' + month
    } else {
        newDate = year + '-0' + month
    }

    return newDate
}
/**
 * 获取上上个月份
 * 输出：'2023-04'
 */
export function getLastTwoMonthsFormatted() {
    const now = new Date();

    // 获取当前月份和年份
    let currentMonth = now.getMonth();
    let currentYear = now.getFullYear();

    // 计算上上个月（当前月份减2，如果小于0则年份减1，月份加12）
    let previousMonth = currentMonth - 2;
    if (previousMonth < 0) {
        previousMonth += 12;
        currentYear -= 1;
    }

    // 格式化年份和月份为yyyy-mm
    const formattedMonth = String(currentYear).padStart(4, '0') + '-' +
        String(previousMonth + 1).padStart(2, '0'); // 月份在返回时需要+1，因为getMonth()返回的是0-11

    return formattedMonth;
}
/**
 * 获取上个年份
 * 输出：'2023'
 */
export function lastYear() {
    let dateTime = new Date().getFullYear() /* 获取现在的年份 */

    return new Date(new Date().setFullYear(dateTime - 1)).getFullYear().toString()
}
/**
 * 获取当前日期
 * 输出：'2024-11-19'
 */
export function getCurrentDate() {
    const now = new Date();
    const year = now.getFullYear();
    const month = String(now.getMonth() + 1).padStart(2, '0'); // 月份从0开始，所以需要+1，并用padStart补全到2位
    const day = String(now.getDate()).padStart(2, '0'); // 日期用padStart补全到2位

    return `${year}-${month}-${day}`;
}
/**
 * 获取当前月份
 * 输出：'2023-06'
 */
export function thisMonth() {
    var date = new Date();
    var year = date.getFullYear();
    var month = date.getMonth() + 1;

    month = month > 9 ? month : "0" + month;

    var nowMonth = year + "-" + month;

    return nowMonth;
}
/**
 * 获取当前年份
 * 输出：'2024'
 */
export function thisYear() {
    let dateTime = new Date().getFullYear() /* 获取现在的年份 */

    return new Date(new Date().setFullYear(dateTime)).getFullYear().toString()
}
/**
 * 日期转换
 * 输入：'date/time'
 * 输出：'2021-09-27/2021-09-27 15:24:46'
 */
export const formatDate = (format = 'date', date = new Date()) => {
    const y = date.getFullYear()
    const m = date.getMonth() + 1
    const d = date.getDate()
    const h = date.getHours()
    const minute = date.getMinutes()
    const second = date.getSeconds()
    const reg = /-(\d)(?!\d)/g
    let datetime

    if (format == 'date') {
        datetime = (y + '-' + m + '-' + d).replace(reg, '-0$1')
    } else if (format == 'time') {
        datetime = (y + '-' + m + '-' + d + ' ' + h + ':' + minute + ':' + second).replace(reg, '-0$1')
    }

    return datetime
}
/**
 * 获取输入年月日的下一日
 * 输入："2023-09-01"
 * 输出："2023-09-02"
 */
export function getNextDay(dateStr) {
    // 验证输入格式  
    const regex = /^(\d{4})-(\d{2})-(\d{2})$/;
    const match = dateStr.match(regex);
    if (!match) {
        throw new Error('输入格式必须为yyyy-mm-dd');
    }

    const [, year, month, day] = match;
    const date = new Date(year, month - 1, day); // 注意：月份在Date对象中是从0开始的  

    // 设置日期为下一天  
    date.setDate(date.getDate() + 1);

    // 格式化日期为yyyy-mm-dd字符串  
    const nextDayStr = date.getFullYear() + '-' +
        String(date.getMonth() + 1).padStart(2, '0') + '-' +
        String(date.getDate()).padStart(2, '0');

    return nextDayStr;
}
/**
 * 获取输入年的12个月
 * 输入：'2023'
 * 输出：['202301', '202402', '202403', '202404', '202405', '202406', '202407', '202408', '202409', '202410', '202411', '202412']
 */
export function getMonthsOfYear(year) {
    // 检查输入是否为有效的年份（可选）  
    if (!/^\d{4}$/.test(year)) {
        console.error('输入必须是4位数字的年份');
        return;
    }

    // 使用模板字符串和map函数来生成每个月份  
    const months = Array.from({ length: 12 }, (_, index) => {
        // index+1是因为数组索引是从0开始的，而月份是从1开始的  
        const month = (index + 1).toString().padStart(2, '0'); // 确保月份是两位数  
        return `${year}${month}`;
    });

    return months;
}
/**
 * 获取输入年月的前6月（包含当前月）
 * 输入：'2024-05'
 * 输出：['202312', '202401', '202402', '202403', '202404', '202405']
 */
export function getPreviousSixMonths(currentYearMonth) {
    // 将年月字符串转换为Date对象  
    const parts = currentYearMonth.split('-');
    const year = parseInt(parts[0], 10);
    const month = parseInt(parts[1], 10) - 1; // 月份是从0开始的，所以需要减1  
    const date = new Date(year, month, 1); // 设置为该月的第一天  

    // 存储前6个月（包括当前月）的年月  
    const previousMonths = [];

    for (let i = 0; i < 6; i++) {
        // 获取年月字符串  
        const yearStr = String(date.getFullYear()).padStart(4, '0');
        const monthStr = String(date.getMonth() + 1).padStart(2, '0'); // 月份加1后转换为字符串  
        const yearMonthStr = `${yearStr}${monthStr}`;

        // 添加到数组中  
        previousMonths.unshift(yearMonthStr);

        // 减去一个月  
        date.setMonth(date.getMonth() - 1);
    }

    // 返回前6个月（包括当前月）的年月数组  
    return previousMonths;
}
/**
 * 获取输入年的前6年（包含当前年）
 * 输入：'2024'
 * 输出：[2019, 2020, 2021, 2022, 2023, 2024]
 */
export function getPreviousSixYears(currentYear) {
    // 确保输入是有效的年份（这里只是简单地转换为数字，没有进行复杂的验证）  
    const year = parseInt(currentYear, 10);
    if (isNaN(year) || year < 0) {
        throw new Error('Invalid year. Must be a non-negative integer.');
    }

    // 初始化一个空数组来存储年份  
    const years = [];

    // 从当前年份开始，往回数6年（包括当前年）  
    for (let i = 0; i <= 5; i++) {
        years.unshift(year - i); // 将年份添加到数组开头  
    }

    return years;
}
/**
 * 获取输入月的前12个月(包含当月)
 * 输入："09"
 * 输出：['10', '11', '12', '01', '02', '03', '04', '05', '06', '07', '08', '09']
 */
export function getPreviousTwelveMonths(currentMonth) {
    // 将月份转换为数字，并确保它在1到12的范围内  
    let monthNum = parseInt(currentMonth, 10);
    if (isNaN(monthNum) || monthNum < 1 || monthNum > 12) {
        throw new Error('Invalid month. Must be between 1 and 12.');
    }

    // 初始化一个空数组来存储月份  
    const months = [];

    // 生成前12个月的列表（包括当前月）  
    for (let i = 0; i < 12; i++) {
        let prevMonth = (monthNum - 1 - i + 12) % 12 + 1; // 处理月份回绕  
        // 将月份转换为两位数的字符串，如果需要的话  
        months.unshift(prevMonth.toString().padStart(2, '0'));
    }

    return months;
}
/**
 * 获取输入年月的前12个月(包含当月)
 * 输入："2023-09"
 * 输出：['2022-10', '2022-11', '2022-12', '2023-01', '2023-02', '2023-03', '2023-04', '2023-05', '2023-06', '2023-07', '2023-08', '2023-09']
 */
export function getPreviousTwelveMonths1(inputMonth) {
    // 验证输入的月份格式  
    const regex = /^\d{4}-\d{2}$/;
    if (!regex.test(inputMonth)) {
        throw new Error('Invalid month format. Expected format: yyyy-mm');
    }

    // 提取年份和月份  
    const [year, month] = inputMonth.split('-').map(Number);
    const months = [];

    // 初始化月份和年份为当前输入的值  
    let currentMonth = month;
    let currentYear = year;

    // 往前推12个月  
    for (let i = 0; i < 12; i++) {
        // 将月份和年份添加到数组中  
        months.unshift(`${currentYear}-${String(currentMonth).padStart(2, '0')}`);

        // 月份减1，如果月份小于1，则年份减1，月份变为12  
        currentMonth--;
        if (currentMonth < 1) {
            currentMonth = 12;
            currentYear--;
        }
    }

    return months;
}
/**
 * 获取输入年月的前12个月(包含当月)
 * 输入："2023-09"
 * 输出：['202210', '202211', '202212', '202301', '202302', '202303', '202304', '202305', '202306', '202307', '202308', '202309']
 */
export function getPreviousTwelveMonths2(inputMonth) {
    // 验证输入的月份格式  
    const regex = /^\d{4}-\d{2}$/;
    if (!regex.test(inputMonth)) {
        throw new Error('Invalid month format. Expected format: yyyy-mm');
    }

    // 提取年份和月份  
    const [year, month] = inputMonth.split('-').map(Number);
    const months = [];

    // 初始化月份和年份为当前输入的值  
    let currentMonth = month;
    let currentYear = year;

    // 往前推12个月  
    for (let i = 0; i < 12; i++) {
        // 将月份和年份添加到数组中  
        months.unshift(`${currentYear}${String(currentMonth).padStart(2, '0')}`);

        // 月份减1，如果月份小于1，则年份减1，月份变为12  
        currentMonth--;
        if (currentMonth < 1) {
            currentMonth = 12;
            currentYear--;
        }
    }

    return months;
}
/**
 * 获取输入年月的前12个月(包含当月)
 * 输入："2023年9月"
 * 输出：['2022年10', '2022年11', '2022年12', '2023年01', '2023年02', '2023年03', '2023年04', '2023年05', '2023年06', '2023年年07', '2023年08', '2023年09']
 */
export function getPreviousTwelveMonths3(yearMonth) {
    // 验证输入格式  
    const regex = /^(\d{4})年(\d{1,2})月$/;
    const match = yearMonth.match(regex);
    if (!match) {
        throw new Error('输入格式必须为yyyy年m月');
    }

    const [, year, month] = match;
    const currentMonth = parseInt(month, 10);
    const previousMonths = [];

    // 遍历前12个月  
    for (let i = 0; i < 12; i++) {
        // 计算前12个月中的每一个月份  
        let prevMonth = currentMonth - i;
        let prevYear = year;

        // 处理月份小于1的情况，需要借年  
        if (prevMonth < 1) {
            prevMonth += 12;
            prevYear -= 1;
        }

        // 格式化为两位数的月份  
        const formattedMonth = prevMonth.toString().padStart(2, '0');

        // 添加到结果数组中  
        previousMonths.unshift(`${prevYear}年${formattedMonth}月`);
    }

    return previousMonths;
}
/**
 * 获取输入年月的前12个月(包含当月)
 * 输入："2023年9月"
 * 输出：['2022年10', '2022年11', '2022年12', '2023年1', '2023年2', '2023年3', '2023年4', '2023年5', '2023年6', '2023年年7', '2023年8', '2023年9']
 */
export function getPreviousTwelveMonths4(yearMonth) {
    // 验证输入格式  
    const regex = /^(\d{4})年(\d{1,2})月$/;
    const match = yearMonth.match(regex);
    if (!match) {
        throw new Error('输入格式必须为yyyy年m月');
    }

    const [, year, month] = match;
    const currentMonth = parseInt(month, 10);
    const previousMonths = [];

    // 遍历前12个月  
    for (let i = 0; i < 12; i++) {
        // 计算前12个月中的每一个月份  
        let prevMonth = currentMonth - i;
        let prevYear = year;

        // 处理月份小于1的情况，需要借年  
        if (prevMonth < 1) {
            prevMonth += 12;
            prevYear -= 1;
        }

        // 格式化为两位数的月份  
        // const formattedMonth = prevMonth.toString().padStart(2, '0');

        // 添加到结果数组中  
        // previousMonths.unshift(`${prevYear}年${formattedMonth}月`);
        previousMonths.unshift(`${prevYear}年${prevMonth}月`);
    }

    return previousMonths;
}
/**
 * 获取输入月接来的12个月(包含当月)
 * 输入：'05'
 * 输出：[5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 3, 4]
 */
export function getNextTwelveMonths(month) {
    // 确保输入的月份在1-12之间  
    // month = (month % 12) + 1;
    month = month % 12;

    // 创建一个空数组来存储结果  
    let nextMonths = [];

    // 循环12次来获取接下来的12个月份  
    for (let i = 0; i < 12; i++) {
        // 使用模数运算来确保月份在1-12之间  
        let nextMonth = (month + i) % 12;
        if (nextMonth === 0) {
            nextMonth = 12; // 如果模数运算结果为0，则月份为12  
        }
        nextMonths.push(nextMonth);
    }

    return nextMonths;
}
/**
 * 获取输入年月接来的12个月(包含当月)
 * 输入："2023-09"
 * 输出：["2023-09", "2023-10", "2023-11", "2023-12", "2024-01", ..., "2024-08"]
 */
export function getNextTwelveMonths1(yearMonthStr) {
    // 分割字符串以获取年份和月份  
    const [yearStr, monthStr] = yearMonthStr.split('-').map(Number);
    // 创建初始的Date对象  
    const date = new Date(yearStr, monthStr - 1, 1); // 注意月份是从0开始的  
    const months = [];

    // 循环12次以获取接下来的12个月份  
    for (let i = 0; i < 12; i++) {
        // 获取当前月份的年份和月份  
        const currentYear = date.getFullYear();
        const currentMonth = String(date.getMonth() + 1).padStart(2, '0'); // 月份+1并转为两位数字  

        // 将当前年份和月份添加到数组中  
        months.push(`${currentYear}-${currentMonth}`);

        // 将日期设置为下一个月的第一天  
        date.setMonth(date.getMonth() + 1);
    }

    return months;
}
/**
 * 获取输入年月接来的12个月(包含当月)
 * 输入："2023-09"
 * 输出：["202309", "202310", "202311", "202312", "202401", ..., "202408"]
 */
export function getNextTwelveMonths2(yearMonthStr) {
    // 分割字符串以获取年份和月份  
    const [yearStr, monthStr] = yearMonthStr.split('-').map(Number);
    // 创建初始的Date对象  
    const date = new Date(yearStr, monthStr - 1, 1); // 注意月份是从0开始的  
    const months = [];

    // 循环12次以获取接下来的12个月份  
    for (let i = 0; i < 12; i++) {
        // 获取当前月份的年份和月份  
        const currentYear = date.getFullYear();
        const currentMonth = String(date.getMonth() + 1).padStart(2, '0'); // 月份+1并转为两位数字  

        // 将当前年份和月份添加到数组中  
        months.push(`${currentYear}${currentMonth}`);

        // 将日期设置为下一个月的第一天  
        date.setMonth(date.getMonth() + 1);
    }

    return months;
}
/**
 * 获取输入年月的前4个季度(包含输入年月所在的季度)
 * 输入："2024-07"
 * 输出：['2023Q4', '2024Q1', '2024Q2', '2024Q3']
 */
export function getPreviousFourQuarters(yearMonth) {
    // 验证输入格式  
    if (!/^\d{4}-\d{2}$/.test(yearMonth)) {
        throw new Error('Invalid input format. Expected yyyy-mm.');
    }

    // 分割年月  
    const [year, month] = yearMonth.split('-');
    const monthNum = parseInt(month, 10);

    // 计算当前月份所在的季度  
    const currentQuarter = Math.ceil(monthNum / 3);

    // 初始化结果数组，并先添加当前年份的季度（从当前季度向前）  
    let quarters = [];
    for (let q = currentQuarter; q >= 1; q--) {
        quarters.push(`${year}Q${q}`);
    }

    // 如果结果数组中的季度数少于4个，则继续添加前一年的季度  
    let prevYear = parseInt(year, 10) - 1;
    for (let q = 4; quarters.length < 4 && q >= 1; q--) {
        quarters.unshift(`${prevYear}Q${q}`);
    }

    // 定义一个比较函数，用于sort()方法  
    function compareQuarters(a, b) {
        // 解析yyyyQ格式的字符串为年份和季度  
        const [yearA, quarterA] = a.split('Q').map(Number);
        const [yearB, quarterB] = b.split('Q').map(Number);

        // 首先比较年份  
        if (yearA !== yearB) {
            return yearA - yearB;
        }

        // 如果年份相同，则比较季度  
        return quarterA - quarterB;
    }

    // 使用sort()方法和比较函数对数组进行排序  
    quarters.sort(compareQuarters);

    // 返回排序后的数组  
    return quarters;
}